// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.receipt;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.Receipt;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(Receipt.class)
@Setter
@Getter
public class ReceiptSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "Receipt".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("docRelate", "po");
    map.put("warehouse", "w");
    map.put("supplier", "s");
    map.put("shipmentEnterprise", "lp");
    map.put("buyer", "su");
    map.put("creator", "su2");
    map.put("createUser", "su3");
    map.put("consignee", "su4");
    map.put("clerk", "w2");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();
    map.put(
      "receiptList.shopId",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN receipt_product AS RO_1 ON RO_1.del_flag = 0 AND RO_1.parent_receipt = t.id"
        )
        .setTableAlias("RO_1")
        .setColumnName("shop_id")
        .setNeedGroupBy(true)
    );
    map.put(
      "receiptList.qcStatus",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN receipt_product AS RO_2 ON RO_2.del_flag = 0 AND RO_2.parent_receipt = t.id"
        )
        .setTableAlias("RO_2")
        .setColumnName("qc_status")
        .setNeedGroupBy(true)
    );
    map.put(
      "receiptList.productId",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN receipt_product AS RO_3 ON RO_3.del_flag = 0 AND RO_3.parent_receipt = t.id"
        )
        .setTableAlias("RO_3")
        .setColumnName("product_id")
        .setNeedGroupBy(true)
    );
    map.put(
      "receiptList.sku",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN receipt_product AS RO_4 ON RO_4.del_flag = 0 AND RO_4.parent_receipt = t.id"
        )
        .setTableAlias("RO_4")
        .setColumnName("sku")
        .setNeedGroupBy(true)
    );
    map.put(
      "receiptList.fnsku",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN receipt_product AS RO_5 ON RO_5.del_flag = 0 AND RO_5.parent_receipt = t.id"
        )
        .setTableAlias("RO_5")
        .setColumnName("fnsku")
        .setNeedGroupBy(true)
    );
    map.put(
      "receiptList.remarks",
      new OptionalJoinField()
        .setJoinPart(
          "LEFT JOIN receipt_product AS RO_6 ON RO_6.del_flag = 0 AND RO_6.parent_receipt = t.id"
        )
        .setTableAlias("RO_6")
        .setColumnName("remarks")
        .setNeedGroupBy(true)
    );

    return map;
  }

  private Long receiptList_shopId;
  private List<String> receiptList_shopIdInList;
  private String receiptList_qcStatus;
  private List<String> receiptList_qcStatusInList;
  private Long receiptList_productId;
  private List<String> receiptList_productIdInList;
  private String receiptList_sku;
  private List<String> receiptList_skuInList;
  private Long receiptList_fnsku;
  private List<String> receiptList_fnskuInList;
  private String receiptList_remarks;
  private List<String> receiptList_remarksInList;

  /**
   * 指定使用特定的视图过滤条件
   * <p>
   * 有效值包括：Receipt/All1, Receipt/WaitForReceiving, Receipt/Done
   * </p>
   */
  private String byViewName;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 收货单号(模糊搜索)
   */
  private String orderSn;

  /**
   * 收货单号 比较(eq)
   */
  private String orderSnEq;
  /**
   * 收货单号 比较(neq)
   */
  private String orderSnNeq;
  /**
   * 收货单号 比较(gt)
   */
  private String orderSnGt;
  /**
   * 收货单号 比较(gte)
   */
  private String orderSnGte;
  /**
   * 收货单号 比较(lt)
   */
  private String orderSnLt;
  /**
   * 收货单号 比较(lte)
   */
  private String orderSnLte;
  /**
   * 收货单号 比较(contains)
   */
  private String orderSnContains;
  /**
   * 收货单号 比较(notcontains)
   */
  private String orderSnNotcontains;
  /**
   * 收货单号 比较(startswith)
   */
  private String orderSnStartswith;
  /**
   * 收货单号 比较(endswith)
   */
  private String orderSnEndswith;
  /**
   * 收货单号 比较(isnull)
   */
  private Boolean orderSnIsnull;
  /**
   * 收货单号 比较(isnotnull)
   */
  private Boolean orderSnIsnotnull;

  /**
   * 收货单号(精确搜索)
   */
  private List<String> orderSnInList;

  /**
   * 收货类型
   */
  private String receiptType;

  /**
   * 收货类型 比较(eq)
   */
  private String receiptTypeEq;
  /**
   * 收货类型 比较(neq)
   */
  private String receiptTypeNeq;
  /**
   * 收货类型 比较(gt)
   */
  private String receiptTypeGt;
  /**
   * 收货类型 比较(gte)
   */
  private String receiptTypeGte;
  /**
   * 收货类型 比较(lt)
   */
  private String receiptTypeLt;
  /**
   * 收货类型 比较(lte)
   */
  private String receiptTypeLte;
  /**
   * 收货类型 比较(contains)
   */
  private String receiptTypeContains;
  /**
   * 收货类型 比较(notcontains)
   */
  private String receiptTypeNotcontains;
  /**
   * 收货类型 比较(startswith)
   */
  private String receiptTypeStartswith;
  /**
   * 收货类型 比较(endswith)
   */
  private String receiptTypeEndswith;
  /**
   * 收货类型 比较(isnull)
   */
  private Boolean receiptTypeIsnull;
  /**
   * 收货类型 比较(isnotnull)
   */
  private Boolean receiptTypeIsnotnull;

  /**
   * 收货类型(精确搜索)
   */
  private List<String> receiptTypeInList;

  /**
   * 关联单据号
   */
  private Long docRelate;

  /**
   * 关联单据号 比较(eq)
   */
  private Long docRelateEq;
  /**
   * 关联单据号 比较(neq)
   */
  private Long docRelateNeq;
  /**
   * 关联单据号 比较(gt)
   */
  private Long docRelateGt;
  /**
   * 关联单据号 比较(gte)
   */
  private Long docRelateGte;
  /**
   * 关联单据号 比较(lt)
   */
  private Long docRelateLt;
  /**
   * 关联单据号 比较(lte)
   */
  private Long docRelateLte;
  /**
   * 关联单据号 比较(contains)
   */
  private Long docRelateContains;
  /**
   * 关联单据号 比较(notcontains)
   */
  private Long docRelateNotcontains;
  /**
   * 关联单据号 比较(startswith)
   */
  private Long docRelateStartswith;
  /**
   * 关联单据号 比较(endswith)
   */
  private Long docRelateEndswith;
  /**
   * 关联单据号 比较(isnull)
   */
  private Boolean docRelateIsnull;
  /**
   * 关联单据号 比较(isnotnull)
   */
  private Boolean docRelateIsnotnull;
  /**
   * 关联单据号的采购单号 比较(eq)
   */
  private String docRelatePurchaseOrderCodeEq;
  /**
   * 关联单据号的采购单号 比较(neq)
   */
  private String docRelatePurchaseOrderCodeNeq;
  /**
   * 关联单据号的采购单号 比较(gt)
   */
  private String docRelatePurchaseOrderCodeGt;
  /**
   * 关联单据号的采购单号 比较(gte)
   */
  private String docRelatePurchaseOrderCodeGte;
  /**
   * 关联单据号的采购单号 比较(lt)
   */
  private String docRelatePurchaseOrderCodeLt;
  /**
   * 关联单据号的采购单号 比较(lte)
   */
  private String docRelatePurchaseOrderCodeLte;
  /**
   * 关联单据号的采购单号 比较(contains)
   */
  private String docRelatePurchaseOrderCodeContains;
  /**
   * 关联单据号的采购单号 比较(notcontains)
   */
  private String docRelatePurchaseOrderCodeNotcontains;
  /**
   * 关联单据号的采购单号 比较(startswith)
   */
  private String docRelatePurchaseOrderCodeStartswith;
  /**
   * 关联单据号的采购单号 比较(endswith)
   */
  private String docRelatePurchaseOrderCodeEndswith;
  /**
   * 关联单据号的采购单号 比较(isnull)
   */
  private Boolean docRelatePurchaseOrderCodeIsnull;
  /**
   * 关联单据号的采购单号 比较(isnotnull)
   */
  private Boolean docRelatePurchaseOrderCodeIsnotnull;

  /**
   * 关联单据号(范围搜索)
   */
  private List<Long> docRelateInList;

  /**
   * 仓库
   */
  private Long warehouse;

  /**
   * 仓库 比较(eq)
   */
  private Long warehouseEq;
  /**
   * 仓库 比较(neq)
   */
  private Long warehouseNeq;
  /**
   * 仓库 比较(gt)
   */
  private Long warehouseGt;
  /**
   * 仓库 比较(gte)
   */
  private Long warehouseGte;
  /**
   * 仓库 比较(lt)
   */
  private Long warehouseLt;
  /**
   * 仓库 比较(lte)
   */
  private Long warehouseLte;
  /**
   * 仓库 比较(contains)
   */
  private Long warehouseContains;
  /**
   * 仓库 比较(notcontains)
   */
  private Long warehouseNotcontains;
  /**
   * 仓库 比较(startswith)
   */
  private Long warehouseStartswith;
  /**
   * 仓库 比较(endswith)
   */
  private Long warehouseEndswith;
  /**
   * 仓库 比较(isnull)
   */
  private Boolean warehouseIsnull;
  /**
   * 仓库 比较(isnotnull)
   */
  private Boolean warehouseIsnotnull;
  /**
   * 仓库的仓库名称 比较(eq)
   */
  private String warehouseNameEq;
  /**
   * 仓库的仓库名称 比较(neq)
   */
  private String warehouseNameNeq;
  /**
   * 仓库的仓库名称 比较(gt)
   */
  private String warehouseNameGt;
  /**
   * 仓库的仓库名称 比较(gte)
   */
  private String warehouseNameGte;
  /**
   * 仓库的仓库名称 比较(lt)
   */
  private String warehouseNameLt;
  /**
   * 仓库的仓库名称 比较(lte)
   */
  private String warehouseNameLte;
  /**
   * 仓库的仓库名称 比较(contains)
   */
  private String warehouseNameContains;
  /**
   * 仓库的仓库名称 比较(notcontains)
   */
  private String warehouseNameNotcontains;
  /**
   * 仓库的仓库名称 比较(startswith)
   */
  private String warehouseNameStartswith;
  /**
   * 仓库的仓库名称 比较(endswith)
   */
  private String warehouseNameEndswith;
  /**
   * 仓库的仓库名称 比较(isnull)
   */
  private Boolean warehouseNameIsnull;
  /**
   * 仓库的仓库名称 比较(isnotnull)
   */
  private Boolean warehouseNameIsnotnull;

  /**
   * 仓库(范围搜索)
   */
  private List<Long> warehouseInList;

  /**
   * 供应商
   */
  private Long supplier;

  /**
   * 供应商 比较(eq)
   */
  private Long supplierEq;
  /**
   * 供应商 比较(neq)
   */
  private Long supplierNeq;
  /**
   * 供应商 比较(gt)
   */
  private Long supplierGt;
  /**
   * 供应商 比较(gte)
   */
  private Long supplierGte;
  /**
   * 供应商 比较(lt)
   */
  private Long supplierLt;
  /**
   * 供应商 比较(lte)
   */
  private Long supplierLte;
  /**
   * 供应商 比较(contains)
   */
  private Long supplierContains;
  /**
   * 供应商 比较(notcontains)
   */
  private Long supplierNotcontains;
  /**
   * 供应商 比较(startswith)
   */
  private Long supplierStartswith;
  /**
   * 供应商 比较(endswith)
   */
  private Long supplierEndswith;
  /**
   * 供应商 比较(isnull)
   */
  private Boolean supplierIsnull;
  /**
   * 供应商 比较(isnotnull)
   */
  private Boolean supplierIsnotnull;
  /**
   * 供应商的供应商简称 比较(eq)
   */
  private String supplierSupplierNameEq;
  /**
   * 供应商的供应商简称 比较(neq)
   */
  private String supplierSupplierNameNeq;
  /**
   * 供应商的供应商简称 比较(gt)
   */
  private String supplierSupplierNameGt;
  /**
   * 供应商的供应商简称 比较(gte)
   */
  private String supplierSupplierNameGte;
  /**
   * 供应商的供应商简称 比较(lt)
   */
  private String supplierSupplierNameLt;
  /**
   * 供应商的供应商简称 比较(lte)
   */
  private String supplierSupplierNameLte;
  /**
   * 供应商的供应商简称 比较(contains)
   */
  private String supplierSupplierNameContains;
  /**
   * 供应商的供应商简称 比较(notcontains)
   */
  private String supplierSupplierNameNotcontains;
  /**
   * 供应商的供应商简称 比较(startswith)
   */
  private String supplierSupplierNameStartswith;
  /**
   * 供应商的供应商简称 比较(endswith)
   */
  private String supplierSupplierNameEndswith;
  /**
   * 供应商的供应商简称 比较(isnull)
   */
  private Boolean supplierSupplierNameIsnull;
  /**
   * 供应商的供应商简称 比较(isnotnull)
   */
  private Boolean supplierSupplierNameIsnotnull;

  /**
   * 供应商(范围搜索)
   */
  private List<Long> supplierInList;

  /**
   * 最早预计到货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date arrivalGoodDateStart;

  /**
   * 最晚预计到货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date arrivalGoodDateEnd;

  /**
   * 预计到货时间 比较(eq)
   */
  private Date arrivalGoodDateEq;
  /**
   * 预计到货时间 比较(neq)
   */
  private Date arrivalGoodDateNeq;
  /**
   * 预计到货时间 比较(gt)
   */
  private Date arrivalGoodDateGt;
  /**
   * 预计到货时间 比较(gte)
   */
  private Date arrivalGoodDateGte;
  /**
   * 预计到货时间 比较(lt)
   */
  private Date arrivalGoodDateLt;
  /**
   * 预计到货时间 比较(lte)
   */
  private Date arrivalGoodDateLte;
  /**
   * 预计到货时间 比较(contains)
   */
  private Date arrivalGoodDateContains;
  /**
   * 预计到货时间 比较(notcontains)
   */
  private Date arrivalGoodDateNotcontains;
  /**
   * 预计到货时间 比较(startswith)
   */
  private Date arrivalGoodDateStartswith;
  /**
   * 预计到货时间 比较(endswith)
   */
  private Date arrivalGoodDateEndswith;
  /**
   * 预计到货时间 比较(isnull)
   */
  private Boolean arrivalGoodDateIsnull;
  /**
   * 预计到货时间 比较(isnotnull)
   */
  private Boolean arrivalGoodDateIsnotnull;

  /**
   * 物流商
   */
  private Long shipmentEnterprise;

  /**
   * 物流商 比较(eq)
   */
  private Long shipmentEnterpriseEq;
  /**
   * 物流商 比较(neq)
   */
  private Long shipmentEnterpriseNeq;
  /**
   * 物流商 比较(gt)
   */
  private Long shipmentEnterpriseGt;
  /**
   * 物流商 比较(gte)
   */
  private Long shipmentEnterpriseGte;
  /**
   * 物流商 比较(lt)
   */
  private Long shipmentEnterpriseLt;
  /**
   * 物流商 比较(lte)
   */
  private Long shipmentEnterpriseLte;
  /**
   * 物流商 比较(contains)
   */
  private Long shipmentEnterpriseContains;
  /**
   * 物流商 比较(notcontains)
   */
  private Long shipmentEnterpriseNotcontains;
  /**
   * 物流商 比较(startswith)
   */
  private Long shipmentEnterpriseStartswith;
  /**
   * 物流商 比较(endswith)
   */
  private Long shipmentEnterpriseEndswith;
  /**
   * 物流商 比较(isnull)
   */
  private Boolean shipmentEnterpriseIsnull;
  /**
   * 物流商 比较(isnotnull)
   */
  private Boolean shipmentEnterpriseIsnotnull;
  /**
   * 物流商的物流商 比较(eq)
   */
  private String shipmentEnterpriseNameEq;
  /**
   * 物流商的物流商 比较(neq)
   */
  private String shipmentEnterpriseNameNeq;
  /**
   * 物流商的物流商 比较(gt)
   */
  private String shipmentEnterpriseNameGt;
  /**
   * 物流商的物流商 比较(gte)
   */
  private String shipmentEnterpriseNameGte;
  /**
   * 物流商的物流商 比较(lt)
   */
  private String shipmentEnterpriseNameLt;
  /**
   * 物流商的物流商 比较(lte)
   */
  private String shipmentEnterpriseNameLte;
  /**
   * 物流商的物流商 比较(contains)
   */
  private String shipmentEnterpriseNameContains;
  /**
   * 物流商的物流商 比较(notcontains)
   */
  private String shipmentEnterpriseNameNotcontains;
  /**
   * 物流商的物流商 比较(startswith)
   */
  private String shipmentEnterpriseNameStartswith;
  /**
   * 物流商的物流商 比较(endswith)
   */
  private String shipmentEnterpriseNameEndswith;
  /**
   * 物流商的物流商 比较(isnull)
   */
  private Boolean shipmentEnterpriseNameIsnull;
  /**
   * 物流商的物流商 比较(isnotnull)
   */
  private Boolean shipmentEnterpriseNameIsnotnull;

  /**
   * 物流商(范围搜索)
   */
  private List<Long> shipmentEnterpriseInList;

  /**
   * 物流单号(模糊搜索)
   */
  private String logisticsCode;

  /**
   * 物流单号 比较(eq)
   */
  private String logisticsCodeEq;
  /**
   * 物流单号 比较(neq)
   */
  private String logisticsCodeNeq;
  /**
   * 物流单号 比较(gt)
   */
  private String logisticsCodeGt;
  /**
   * 物流单号 比较(gte)
   */
  private String logisticsCodeGte;
  /**
   * 物流单号 比较(lt)
   */
  private String logisticsCodeLt;
  /**
   * 物流单号 比较(lte)
   */
  private String logisticsCodeLte;
  /**
   * 物流单号 比较(contains)
   */
  private String logisticsCodeContains;
  /**
   * 物流单号 比较(notcontains)
   */
  private String logisticsCodeNotcontains;
  /**
   * 物流单号 比较(startswith)
   */
  private String logisticsCodeStartswith;
  /**
   * 物流单号 比较(endswith)
   */
  private String logisticsCodeEndswith;
  /**
   * 物流单号 比较(isnull)
   */
  private Boolean logisticsCodeIsnull;
  /**
   * 物流单号 比较(isnotnull)
   */
  private Boolean logisticsCodeIsnotnull;

  /**
   * 物流单号(精确搜索)
   */
  private List<String> logisticsCodeInList;

  /**
   * 采购员
   */
  private Long buyer;

  /**
   * 采购员 比较(eq)
   */
  private Long buyerEq;
  /**
   * 采购员 比较(neq)
   */
  private Long buyerNeq;
  /**
   * 采购员 比较(gt)
   */
  private Long buyerGt;
  /**
   * 采购员 比较(gte)
   */
  private Long buyerGte;
  /**
   * 采购员 比较(lt)
   */
  private Long buyerLt;
  /**
   * 采购员 比较(lte)
   */
  private Long buyerLte;
  /**
   * 采购员 比较(contains)
   */
  private Long buyerContains;
  /**
   * 采购员 比较(notcontains)
   */
  private Long buyerNotcontains;
  /**
   * 采购员 比较(startswith)
   */
  private Long buyerStartswith;
  /**
   * 采购员 比较(endswith)
   */
  private Long buyerEndswith;
  /**
   * 采购员 比较(isnull)
   */
  private Boolean buyerIsnull;
  /**
   * 采购员 比较(isnotnull)
   */
  private Boolean buyerIsnotnull;
  /**
   * 采购员的显示用户名 比较(eq)
   */
  private String buyerNameEq;
  /**
   * 采购员的显示用户名 比较(neq)
   */
  private String buyerNameNeq;
  /**
   * 采购员的显示用户名 比较(gt)
   */
  private String buyerNameGt;
  /**
   * 采购员的显示用户名 比较(gte)
   */
  private String buyerNameGte;
  /**
   * 采购员的显示用户名 比较(lt)
   */
  private String buyerNameLt;
  /**
   * 采购员的显示用户名 比较(lte)
   */
  private String buyerNameLte;
  /**
   * 采购员的显示用户名 比较(contains)
   */
  private String buyerNameContains;
  /**
   * 采购员的显示用户名 比较(notcontains)
   */
  private String buyerNameNotcontains;
  /**
   * 采购员的显示用户名 比较(startswith)
   */
  private String buyerNameStartswith;
  /**
   * 采购员的显示用户名 比较(endswith)
   */
  private String buyerNameEndswith;
  /**
   * 采购员的显示用户名 比较(isnull)
   */
  private Boolean buyerNameIsnull;
  /**
   * 采购员的显示用户名 比较(isnotnull)
   */
  private Boolean buyerNameIsnotnull;

  /**
   * 采购员(范围搜索)
   */
  private List<Long> buyerInList;

  /**
   * 自定义创建人
   */
  private Long creator;

  /**
   * 自定义创建人 比较(eq)
   */
  private Long creatorEq;
  /**
   * 自定义创建人 比较(neq)
   */
  private Long creatorNeq;
  /**
   * 自定义创建人 比较(gt)
   */
  private Long creatorGt;
  /**
   * 自定义创建人 比较(gte)
   */
  private Long creatorGte;
  /**
   * 自定义创建人 比较(lt)
   */
  private Long creatorLt;
  /**
   * 自定义创建人 比较(lte)
   */
  private Long creatorLte;
  /**
   * 自定义创建人 比较(contains)
   */
  private Long creatorContains;
  /**
   * 自定义创建人 比较(notcontains)
   */
  private Long creatorNotcontains;
  /**
   * 自定义创建人 比较(startswith)
   */
  private Long creatorStartswith;
  /**
   * 自定义创建人 比较(endswith)
   */
  private Long creatorEndswith;
  /**
   * 自定义创建人 比较(isnull)
   */
  private Boolean creatorIsnull;
  /**
   * 自定义创建人 比较(isnotnull)
   */
  private Boolean creatorIsnotnull;
  /**
   * 自定义创建人的显示用户名 比较(eq)
   */
  private String creatorNameEq;
  /**
   * 自定义创建人的显示用户名 比较(neq)
   */
  private String creatorNameNeq;
  /**
   * 自定义创建人的显示用户名 比较(gt)
   */
  private String creatorNameGt;
  /**
   * 自定义创建人的显示用户名 比较(gte)
   */
  private String creatorNameGte;
  /**
   * 自定义创建人的显示用户名 比较(lt)
   */
  private String creatorNameLt;
  /**
   * 自定义创建人的显示用户名 比较(lte)
   */
  private String creatorNameLte;
  /**
   * 自定义创建人的显示用户名 比较(contains)
   */
  private String creatorNameContains;
  /**
   * 自定义创建人的显示用户名 比较(notcontains)
   */
  private String creatorNameNotcontains;
  /**
   * 自定义创建人的显示用户名 比较(startswith)
   */
  private String creatorNameStartswith;
  /**
   * 自定义创建人的显示用户名 比较(endswith)
   */
  private String creatorNameEndswith;
  /**
   * 自定义创建人的显示用户名 比较(isnull)
   */
  private Boolean creatorNameIsnull;
  /**
   * 自定义创建人的显示用户名 比较(isnotnull)
   */
  private Boolean creatorNameIsnotnull;

  /**
   * 自定义创建人(范围搜索)
   */
  private List<Long> creatorInList;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;
  /**
   * 创建人的显示用户名 比较(eq)
   */
  private String createUserNameEq;
  /**
   * 创建人的显示用户名 比较(neq)
   */
  private String createUserNameNeq;
  /**
   * 创建人的显示用户名 比较(gt)
   */
  private String createUserNameGt;
  /**
   * 创建人的显示用户名 比较(gte)
   */
  private String createUserNameGte;
  /**
   * 创建人的显示用户名 比较(lt)
   */
  private String createUserNameLt;
  /**
   * 创建人的显示用户名 比较(lte)
   */
  private String createUserNameLte;
  /**
   * 创建人的显示用户名 比较(contains)
   */
  private String createUserNameContains;
  /**
   * 创建人的显示用户名 比较(notcontains)
   */
  private String createUserNameNotcontains;
  /**
   * 创建人的显示用户名 比较(startswith)
   */
  private String createUserNameStartswith;
  /**
   * 创建人的显示用户名 比较(endswith)
   */
  private String createUserNameEndswith;
  /**
   * 创建人的显示用户名 比较(isnull)
   */
  private Boolean createUserNameIsnull;
  /**
   * 创建人的显示用户名 比较(isnotnull)
   */
  private Boolean createUserNameIsnotnull;

  /**
   * 创建人(范围搜索)
   */
  private List<Long> createUserInList;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 收货人
   */
  private Long consignee;

  /**
   * 收货人 比较(eq)
   */
  private Long consigneeEq;
  /**
   * 收货人 比较(neq)
   */
  private Long consigneeNeq;
  /**
   * 收货人 比较(gt)
   */
  private Long consigneeGt;
  /**
   * 收货人 比较(gte)
   */
  private Long consigneeGte;
  /**
   * 收货人 比较(lt)
   */
  private Long consigneeLt;
  /**
   * 收货人 比较(lte)
   */
  private Long consigneeLte;
  /**
   * 收货人 比较(contains)
   */
  private Long consigneeContains;
  /**
   * 收货人 比较(notcontains)
   */
  private Long consigneeNotcontains;
  /**
   * 收货人 比较(startswith)
   */
  private Long consigneeStartswith;
  /**
   * 收货人 比较(endswith)
   */
  private Long consigneeEndswith;
  /**
   * 收货人 比较(isnull)
   */
  private Boolean consigneeIsnull;
  /**
   * 收货人 比较(isnotnull)
   */
  private Boolean consigneeIsnotnull;
  /**
   * 收货人的显示用户名 比较(eq)
   */
  private String consigneeNameEq;
  /**
   * 收货人的显示用户名 比较(neq)
   */
  private String consigneeNameNeq;
  /**
   * 收货人的显示用户名 比较(gt)
   */
  private String consigneeNameGt;
  /**
   * 收货人的显示用户名 比较(gte)
   */
  private String consigneeNameGte;
  /**
   * 收货人的显示用户名 比较(lt)
   */
  private String consigneeNameLt;
  /**
   * 收货人的显示用户名 比较(lte)
   */
  private String consigneeNameLte;
  /**
   * 收货人的显示用户名 比较(contains)
   */
  private String consigneeNameContains;
  /**
   * 收货人的显示用户名 比较(notcontains)
   */
  private String consigneeNameNotcontains;
  /**
   * 收货人的显示用户名 比较(startswith)
   */
  private String consigneeNameStartswith;
  /**
   * 收货人的显示用户名 比较(endswith)
   */
  private String consigneeNameEndswith;
  /**
   * 收货人的显示用户名 比较(isnull)
   */
  private Boolean consigneeNameIsnull;
  /**
   * 收货人的显示用户名 比较(isnotnull)
   */
  private Boolean consigneeNameIsnotnull;

  /**
   * 收货人(范围搜索)
   */
  private List<Long> consigneeInList;

  /**
   * 最早收货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date receiptDateStart;

  /**
   * 最晚收货时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date receiptDateEnd;

  /**
   * 收货时间 比较(eq)
   */
  private Date receiptDateEq;
  /**
   * 收货时间 比较(neq)
   */
  private Date receiptDateNeq;
  /**
   * 收货时间 比较(gt)
   */
  private Date receiptDateGt;
  /**
   * 收货时间 比较(gte)
   */
  private Date receiptDateGte;
  /**
   * 收货时间 比较(lt)
   */
  private Date receiptDateLt;
  /**
   * 收货时间 比较(lte)
   */
  private Date receiptDateLte;
  /**
   * 收货时间 比较(contains)
   */
  private Date receiptDateContains;
  /**
   * 收货时间 比较(notcontains)
   */
  private Date receiptDateNotcontains;
  /**
   * 收货时间 比较(startswith)
   */
  private Date receiptDateStartswith;
  /**
   * 收货时间 比较(endswith)
   */
  private Date receiptDateEndswith;
  /**
   * 收货时间 比较(isnull)
   */
  private Boolean receiptDateIsnull;
  /**
   * 收货时间 比较(isnotnull)
   */
  private Boolean receiptDateIsnotnull;

  /**
   * 备注(模糊搜索)
   */
  private String remarks;

  /**
   * 备注 比较(eq)
   */
  private String remarksEq;
  /**
   * 备注 比较(neq)
   */
  private String remarksNeq;
  /**
   * 备注 比较(gt)
   */
  private String remarksGt;
  /**
   * 备注 比较(gte)
   */
  private String remarksGte;
  /**
   * 备注 比较(lt)
   */
  private String remarksLt;
  /**
   * 备注 比较(lte)
   */
  private String remarksLte;
  /**
   * 备注 比较(contains)
   */
  private String remarksContains;
  /**
   * 备注 比较(notcontains)
   */
  private String remarksNotcontains;
  /**
   * 备注 比较(startswith)
   */
  private String remarksStartswith;
  /**
   * 备注 比较(endswith)
   */
  private String remarksEndswith;
  /**
   * 备注 比较(isnull)
   */
  private Boolean remarksIsnull;
  /**
   * 备注 比较(isnotnull)
   */
  private Boolean remarksIsnotnull;

  /**
   * 备注(精确搜索)
   */
  private List<String> remarksInList;

  /**
   * 收货仓库
   */
  private Long clerk;

  /**
   * 收货仓库 比较(eq)
   */
  private Long clerkEq;
  /**
   * 收货仓库 比较(neq)
   */
  private Long clerkNeq;
  /**
   * 收货仓库 比较(gt)
   */
  private Long clerkGt;
  /**
   * 收货仓库 比较(gte)
   */
  private Long clerkGte;
  /**
   * 收货仓库 比较(lt)
   */
  private Long clerkLt;
  /**
   * 收货仓库 比较(lte)
   */
  private Long clerkLte;
  /**
   * 收货仓库 比较(contains)
   */
  private Long clerkContains;
  /**
   * 收货仓库 比较(notcontains)
   */
  private Long clerkNotcontains;
  /**
   * 收货仓库 比较(startswith)
   */
  private Long clerkStartswith;
  /**
   * 收货仓库 比较(endswith)
   */
  private Long clerkEndswith;
  /**
   * 收货仓库 比较(isnull)
   */
  private Boolean clerkIsnull;
  /**
   * 收货仓库 比较(isnotnull)
   */
  private Boolean clerkIsnotnull;
  /**
   * 收货仓库的仓库名称 比较(eq)
   */
  private String clerkNameEq;
  /**
   * 收货仓库的仓库名称 比较(neq)
   */
  private String clerkNameNeq;
  /**
   * 收货仓库的仓库名称 比较(gt)
   */
  private String clerkNameGt;
  /**
   * 收货仓库的仓库名称 比较(gte)
   */
  private String clerkNameGte;
  /**
   * 收货仓库的仓库名称 比较(lt)
   */
  private String clerkNameLt;
  /**
   * 收货仓库的仓库名称 比较(lte)
   */
  private String clerkNameLte;
  /**
   * 收货仓库的仓库名称 比较(contains)
   */
  private String clerkNameContains;
  /**
   * 收货仓库的仓库名称 比较(notcontains)
   */
  private String clerkNameNotcontains;
  /**
   * 收货仓库的仓库名称 比较(startswith)
   */
  private String clerkNameStartswith;
  /**
   * 收货仓库的仓库名称 比较(endswith)
   */
  private String clerkNameEndswith;
  /**
   * 收货仓库的仓库名称 比较(isnull)
   */
  private Boolean clerkNameIsnull;
  /**
   * 收货仓库的仓库名称 比较(isnotnull)
   */
  private Boolean clerkNameIsnotnull;

  /**
   * 收货仓库(范围搜索)
   */
  private List<Long> clerkInList;

  /**
   * 单据状态
   */
  private String status;

  /**
   * 单据状态 比较(eq)
   */
  private String statusEq;
  /**
   * 单据状态 比较(neq)
   */
  private String statusNeq;
  /**
   * 单据状态 比较(gt)
   */
  private String statusGt;
  /**
   * 单据状态 比较(gte)
   */
  private String statusGte;
  /**
   * 单据状态 比较(lt)
   */
  private String statusLt;
  /**
   * 单据状态 比较(lte)
   */
  private String statusLte;
  /**
   * 单据状态 比较(contains)
   */
  private String statusContains;
  /**
   * 单据状态 比较(notcontains)
   */
  private String statusNotcontains;
  /**
   * 单据状态 比较(startswith)
   */
  private String statusStartswith;
  /**
   * 单据状态 比较(endswith)
   */
  private String statusEndswith;
  /**
   * 单据状态 比较(isnull)
   */
  private Boolean statusIsnull;
  /**
   * 单据状态 比较(isnotnull)
   */
  private Boolean statusIsnotnull;

  /**
   * 单据状态(精确搜索)
   */
  private List<String> statusInList;

  /**
   * 来源单据(模糊搜索)
   */
  private String businessOrderSn;

  /**
   * 来源单据 比较(eq)
   */
  private String businessOrderSnEq;
  /**
   * 来源单据 比较(neq)
   */
  private String businessOrderSnNeq;
  /**
   * 来源单据 比较(gt)
   */
  private String businessOrderSnGt;
  /**
   * 来源单据 比较(gte)
   */
  private String businessOrderSnGte;
  /**
   * 来源单据 比较(lt)
   */
  private String businessOrderSnLt;
  /**
   * 来源单据 比较(lte)
   */
  private String businessOrderSnLte;
  /**
   * 来源单据 比较(contains)
   */
  private String businessOrderSnContains;
  /**
   * 来源单据 比较(notcontains)
   */
  private String businessOrderSnNotcontains;
  /**
   * 来源单据 比较(startswith)
   */
  private String businessOrderSnStartswith;
  /**
   * 来源单据 比较(endswith)
   */
  private String businessOrderSnEndswith;
  /**
   * 来源单据 比较(isnull)
   */
  private Boolean businessOrderSnIsnull;
  /**
   * 来源单据 比较(isnotnull)
   */
  private Boolean businessOrderSnIsnotnull;

  /**
   * 来源单据(精确搜索)
   */
  private List<String> businessOrderSnInList;

  /**
   * 费用分配方式
   */
  private String costDistribution;

  /**
   * 费用分配方式 比较(eq)
   */
  private String costDistributionEq;
  /**
   * 费用分配方式 比较(neq)
   */
  private String costDistributionNeq;
  /**
   * 费用分配方式 比较(gt)
   */
  private String costDistributionGt;
  /**
   * 费用分配方式 比较(gte)
   */
  private String costDistributionGte;
  /**
   * 费用分配方式 比较(lt)
   */
  private String costDistributionLt;
  /**
   * 费用分配方式 比较(lte)
   */
  private String costDistributionLte;
  /**
   * 费用分配方式 比较(contains)
   */
  private String costDistributionContains;
  /**
   * 费用分配方式 比较(notcontains)
   */
  private String costDistributionNotcontains;
  /**
   * 费用分配方式 比较(startswith)
   */
  private String costDistributionStartswith;
  /**
   * 费用分配方式 比较(endswith)
   */
  private String costDistributionEndswith;
  /**
   * 费用分配方式 比较(isnull)
   */
  private Boolean costDistributionIsnull;
  /**
   * 费用分配方式 比较(isnotnull)
   */
  private Boolean costDistributionIsnotnull;

  /**
   * 费用分配方式(精确搜索)
   */
  private List<String> costDistributionInList;

  /**
   * 运费
   */
  private java.math.BigDecimal freight;

  /**
   * 最小运费
   */
  private java.math.BigDecimal freightMin;

  /**
   * 最大运费
   */
  private java.math.BigDecimal freightMax;

  /**
   * 运费 比较(eq)
   */
  private java.math.BigDecimal freightEq;
  /**
   * 运费 比较(neq)
   */
  private java.math.BigDecimal freightNeq;
  /**
   * 运费 比较(gt)
   */
  private java.math.BigDecimal freightGt;
  /**
   * 运费 比较(gte)
   */
  private java.math.BigDecimal freightGte;
  /**
   * 运费 比较(lt)
   */
  private java.math.BigDecimal freightLt;
  /**
   * 运费 比较(lte)
   */
  private java.math.BigDecimal freightLte;
  /**
   * 运费 比较(contains)
   */
  private java.math.BigDecimal freightContains;
  /**
   * 运费 比较(notcontains)
   */
  private java.math.BigDecimal freightNotcontains;
  /**
   * 运费 比较(startswith)
   */
  private java.math.BigDecimal freightStartswith;
  /**
   * 运费 比较(endswith)
   */
  private java.math.BigDecimal freightEndswith;
  /**
   * 运费 比较(isnull)
   */
  private Boolean freightIsnull;
  /**
   * 运费 比较(isnotnull)
   */
  private Boolean freightIsnotnull;

  /**
   * 其他费用
   */
  private java.math.BigDecimal otherExpenses;

  /**
   * 最小其他费用
   */
  private java.math.BigDecimal otherExpensesMin;

  /**
   * 最大其他费用
   */
  private java.math.BigDecimal otherExpensesMax;

  /**
   * 其他费用 比较(eq)
   */
  private java.math.BigDecimal otherExpensesEq;
  /**
   * 其他费用 比较(neq)
   */
  private java.math.BigDecimal otherExpensesNeq;
  /**
   * 其他费用 比较(gt)
   */
  private java.math.BigDecimal otherExpensesGt;
  /**
   * 其他费用 比较(gte)
   */
  private java.math.BigDecimal otherExpensesGte;
  /**
   * 其他费用 比较(lt)
   */
  private java.math.BigDecimal otherExpensesLt;
  /**
   * 其他费用 比较(lte)
   */
  private java.math.BigDecimal otherExpensesLte;
  /**
   * 其他费用 比较(contains)
   */
  private java.math.BigDecimal otherExpensesContains;
  /**
   * 其他费用 比较(notcontains)
   */
  private java.math.BigDecimal otherExpensesNotcontains;
  /**
   * 其他费用 比较(startswith)
   */
  private java.math.BigDecimal otherExpensesStartswith;
  /**
   * 其他费用 比较(endswith)
   */
  private java.math.BigDecimal otherExpensesEndswith;
  /**
   * 其他费用 比较(isnull)
   */
  private Boolean otherExpensesIsnull;
  /**
   * 其他费用 比较(isnotnull)
   */
  private Boolean otherExpensesIsnotnull;

  /**
   * 是否有 附件
   */
  private Boolean appendix;

  /**
   * 总入库量
   */
  private Integer allTotalStorage;

  /**
   * 最小总入库量
   */
  private Integer allTotalStorageMin;

  /**
   * 最大总入库量
   */
  private Integer allTotalStorageMax;

  /**
   * 总入库量 比较(eq)
   */
  private Integer allTotalStorageEq;
  /**
   * 总入库量 比较(neq)
   */
  private Integer allTotalStorageNeq;
  /**
   * 总入库量 比较(gt)
   */
  private Integer allTotalStorageGt;
  /**
   * 总入库量 比较(gte)
   */
  private Integer allTotalStorageGte;
  /**
   * 总入库量 比较(lt)
   */
  private Integer allTotalStorageLt;
  /**
   * 总入库量 比较(lte)
   */
  private Integer allTotalStorageLte;
  /**
   * 总入库量 比较(contains)
   */
  private Integer allTotalStorageContains;
  /**
   * 总入库量 比较(notcontains)
   */
  private Integer allTotalStorageNotcontains;
  /**
   * 总入库量 比较(startswith)
   */
  private Integer allTotalStorageStartswith;
  /**
   * 总入库量 比较(endswith)
   */
  private Integer allTotalStorageEndswith;
  /**
   * 总入库量 比较(isnull)
   */
  private Boolean allTotalStorageIsnull;
  /**
   * 总入库量 比较(isnotnull)
   */
  private Boolean allTotalStorageIsnotnull;

  /**
   * 源表检测字段(模糊搜索)
   */
  private String detectionFlag;

  /**
   * 源表检测字段 比较(eq)
   */
  private String detectionFlagEq;
  /**
   * 源表检测字段 比较(neq)
   */
  private String detectionFlagNeq;
  /**
   * 源表检测字段 比较(gt)
   */
  private String detectionFlagGt;
  /**
   * 源表检测字段 比较(gte)
   */
  private String detectionFlagGte;
  /**
   * 源表检测字段 比较(lt)
   */
  private String detectionFlagLt;
  /**
   * 源表检测字段 比较(lte)
   */
  private String detectionFlagLte;
  /**
   * 源表检测字段 比较(contains)
   */
  private String detectionFlagContains;
  /**
   * 源表检测字段 比较(notcontains)
   */
  private String detectionFlagNotcontains;
  /**
   * 源表检测字段 比较(startswith)
   */
  private String detectionFlagStartswith;
  /**
   * 源表检测字段 比较(endswith)
   */
  private String detectionFlagEndswith;
  /**
   * 源表检测字段 比较(isnull)
   */
  private Boolean detectionFlagIsnull;
  /**
   * 源表检测字段 比较(isnotnull)
   */
  private Boolean detectionFlagIsnotnull;

  /**
   * 源表检测字段(精确搜索)
   */
  private List<String> detectionFlagInList;

  /**
   * 加急
   */
  private String urgent;

  /**
   * 加急 比较(eq)
   */
  private String urgentEq;
  /**
   * 加急 比较(neq)
   */
  private String urgentNeq;
  /**
   * 加急 比较(gt)
   */
  private String urgentGt;
  /**
   * 加急 比较(gte)
   */
  private String urgentGte;
  /**
   * 加急 比较(lt)
   */
  private String urgentLt;
  /**
   * 加急 比较(lte)
   */
  private String urgentLte;
  /**
   * 加急 比较(contains)
   */
  private String urgentContains;
  /**
   * 加急 比较(notcontains)
   */
  private String urgentNotcontains;
  /**
   * 加急 比较(startswith)
   */
  private String urgentStartswith;
  /**
   * 加急 比较(endswith)
   */
  private String urgentEndswith;
  /**
   * 加急 比较(isnull)
   */
  private Boolean urgentIsnull;
  /**
   * 加急 比较(isnotnull)
   */
  private Boolean urgentIsnotnull;

  /**
   * 加急(精确搜索)
   */
  private List<String> urgentInList;

  /**
   * 通知收货量
   */
  private Integer notificationOfReceiptQuantity;

  /**
   * 最小通知收货量
   */
  private Integer notificationOfReceiptQuantityMin;

  /**
   * 最大通知收货量
   */
  private Integer notificationOfReceiptQuantityMax;

  /**
   * 通知收货量 比较(eq)
   */
  private Integer notificationOfReceiptQuantityEq;
  /**
   * 通知收货量 比较(neq)
   */
  private Integer notificationOfReceiptQuantityNeq;
  /**
   * 通知收货量 比较(gt)
   */
  private Integer notificationOfReceiptQuantityGt;
  /**
   * 通知收货量 比较(gte)
   */
  private Integer notificationOfReceiptQuantityGte;
  /**
   * 通知收货量 比较(lt)
   */
  private Integer notificationOfReceiptQuantityLt;
  /**
   * 通知收货量 比较(lte)
   */
  private Integer notificationOfReceiptQuantityLte;
  /**
   * 通知收货量 比较(contains)
   */
  private Integer notificationOfReceiptQuantityContains;
  /**
   * 通知收货量 比较(notcontains)
   */
  private Integer notificationOfReceiptQuantityNotcontains;
  /**
   * 通知收货量 比较(startswith)
   */
  private Integer notificationOfReceiptQuantityStartswith;
  /**
   * 通知收货量 比较(endswith)
   */
  private Integer notificationOfReceiptQuantityEndswith;
  /**
   * 通知收货量 比较(isnull)
   */
  private Boolean notificationOfReceiptQuantityIsnull;
  /**
   * 通知收货量 比较(isnotnull)
   */
  private Boolean notificationOfReceiptQuantityIsnotnull;

  /**
   * 收货量
   */
  private Integer receiptAboutQuantity;

  /**
   * 最小收货量
   */
  private Integer receiptAboutQuantityMin;

  /**
   * 最大收货量
   */
  private Integer receiptAboutQuantityMax;

  /**
   * 收货量 比较(eq)
   */
  private Integer receiptAboutQuantityEq;
  /**
   * 收货量 比较(neq)
   */
  private Integer receiptAboutQuantityNeq;
  /**
   * 收货量 比较(gt)
   */
  private Integer receiptAboutQuantityGt;
  /**
   * 收货量 比较(gte)
   */
  private Integer receiptAboutQuantityGte;
  /**
   * 收货量 比较(lt)
   */
  private Integer receiptAboutQuantityLt;
  /**
   * 收货量 比较(lte)
   */
  private Integer receiptAboutQuantityLte;
  /**
   * 收货量 比较(contains)
   */
  private Integer receiptAboutQuantityContains;
  /**
   * 收货量 比较(notcontains)
   */
  private Integer receiptAboutQuantityNotcontains;
  /**
   * 收货量 比较(startswith)
   */
  private Integer receiptAboutQuantityStartswith;
  /**
   * 收货量 比较(endswith)
   */
  private Integer receiptAboutQuantityEndswith;
  /**
   * 收货量 比较(isnull)
   */
  private Boolean receiptAboutQuantityIsnull;
  /**
   * 收货量 比较(isnotnull)
   */
  private Boolean receiptAboutQuantityIsnotnull;

  /**
   * 是否有 收货产品
   */
  private Boolean receiptAboutProduct;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
